public class Generics<T extends Comparable<T>> {            //代表指定的参数类型<T>一定实现了这个接口,并且T的上界是Comparable
    //加了<>就表示这个类是泛型类 泛型:是编译时期的一种机制，在运行时与泛型无关
    //public T[] array=(T[])new Object[3];     //因为上界是Comparable，所以他的最高界限就只能是Comparable，不能写成Object
    public T[] array=(T[])new Comparable[3];
    //先把T看做是Object，因为Object是所有类的父类，因此可以存放各种数据，但是取出数据的时候，需要强转
    //以后常用的形式
    //public Object[] obj=new Object[10];

    public T getArray(int pos) {
        return this.array[pos];
    }
    public void setArray(int pos,T val) {
        this.array[pos]=val;
    }
    public  T findMax(T[] array) {
        T max=array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max=array[i];
            }
        }
        return max;
    }
    public static void main(String[] args) {
        //Generics<Integer> g1 = new Generics<>();  //如果<E extends Comparable<E>>那么代表E这个参数类型一定是已经实现了Comparable<E>这个接口的
        Generics<Integer> tGenerics = new Generics<>();
        Integer[] a1={1,5,7,4,3};
        Integer val=tGenerics.findMax(a1);
        System.out.println(val);
        Integer m=10;
        System.out.println(m.compareTo(5));
        //Generics<A>   不能这么写是因为A没有实现comparaable接口
    }
    public static void main3(String[] args) {
        //实例化对象的同时 指定当前泛型类的 指定 参数类型是Integer
        //此时解决了一个问题，不是什么都可以存储 而且获取数据的时候不需要强转
        //指定的参数类型只能是引用数据类型，并且后面<>的Integer可以省略
        Generics<Integer> array=new Generics<Integer>();
        //Generics s=new Generics();
        array.setArray(0,10);
        array.setArray(1,20);
        array.setArray(2,30);
//        s.setArray(1,"he");
//        String a=(String) s.getArray(1);
        Integer val1=array.getArray(1); //这里发生了装箱
        System.out.println(val1);



        Generics<String> s=new Generics<>();
        s.setArray(0,"1");
        s.setArray(1,"2");
        String val=s.getArray(1);
        System.out.println(val);
    }


    public static void main4(String[] args) {
        A<Number> a1=new A<>();
        A<Integer> a2=new A<>();
        A<Short> a3=new A<Short>();
    }
}
class A<T extends Number> {  //传入的参数E要么是Number的子类要么是Number自身

}
//泛型方法
class B {
    public  <T extends Comparable<T>>  T findMax(T[] array) {    //在public后面给定参数类型，加一个static就变成了静态泛型方法
        T max=array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max=array[i];
            }
        }
        return max;
    }

    public static void main2(String[] args) {
        B b=new B();
        Integer[] arr={1,8,5,6,4,7,2};
        System.out.println(b.<Integer>findMax(arr)); //这边的Integer可以省略
    }
}
